\documentclass[a4paper]{article}
\usepackage[utf8]{inputenc}
\usepackage[spanish]{babel}
\usepackage[margin=2.5cm]{geometry}
\usepackage{tikz}
\usepackage{courier}
\usepackage{listings}
%\usepackage{algorithmic}
%\usepackage{algorithm}
%\usepackage{multicol}
%\usepackage{color}
%\usepackage{amssymb}
%\usepackage{amsmath}
%\usepackage{amsthm}
\usepackage[section]{placeins}

\lstset{
%	language=C++,
	basicstyle=\ttfamily,	% print whole listing small
	keywordstyle=\bfseries,
	numbers=left,
	numberstyle=\footnotesize,
	breaklines=true,
    identifierstyle=,		% nothing happens
	stringstyle=\ttfamily,		% typewriter type for strings
	showstringspaces=false,		% no special string spaces
    extendedchars=true,
    morekeywords={REGLA, ATRIBUTO, CONSTANTE, HECHO, ECO, INFORME_HTML, ESTADO, ENTRENAR, PRODUCIR},
    %Para los acentos en el codigo fuente.
    literate=%
        {á}{{\'a}}1
        {í}{{\'i}}1
        {é}{{\'e}}1
        {ý}{{\'y}}1
        {ú}{{\'u}}1
        {ó}{{\'o}}1
        {Ú}{{\'U}}1
}

\title{ 75.67 \\ Sistemas Automáticos de \\ Diagnostico y Detección de Fallas I \\ Trabajo Práctico 3}
\date{}
\author{
	\begin{tabular}{ll}
	79992 & Czelada, Esteban Alejandro \\
	87696 & Cabrera, Laura \\
	89672 & Celentano, Agustin
	\end{tabular}
}

\begin{document}

\maketitle

\abstract{
El presente informe sirve de descripción general de un prototipo de motor de inferencia y su manual de usuario.
Abarca la arquitectura basica del modulo más importante y las anotaciónes importantes de los auxiliares.
Concluye con la construcción de un prototipo de un proceso capaz de procesar información del indice Merval y dar recomendaciones.
}

\section{Arquitectura}
El prototipo esta compuesto por tres partes principales:
\begin{itemize}
    \item El modulo \emph{crawler} provee de un ejecutable simple capaz de recorrer un recurso (remoto o local) y extraer del mismo las tablas html contenidas, para finalmente generar un resumen de hechos compatibles con el motor de inferencia.
    \item Los modulos \emph{evaluador} y \emph{ecuacion} contiene clases de utilidad del motor \emph{motor}.
    \item El modulo \emph{motor} provee las facilidades necesarias para construir una red de inferencia y propagar hechos en ella.
    \item La aplicación \emph{motor.main} funciona como un interprete de comandos. 
\end{itemize}
\section{Modulos}

\subsection{crawler}
Este modulo se a desarrollado a partir del codigo de \emph{James Mills} obtenido de \emph{http:\/\/code.activestate.com\/recipes\/576551-simple-web-crawler\/}.

El codigo original solo consistia en procesar una direccion URL y recursivamente los enlaces incluidos en la misma. Nuestra solución agrega la capacidad de procesar una dirección con el fin de filtrar solo los elmentos HTML \emph{table} y generar un conjunto de atributos y hechos compatibles con la gramatica del motor de inferencia.

Para lograrlo se ha extendido la funcionalidad agregando dos banderas más al ejecutable:
\begin{itemize}
    \item -F, --file [archivo]; Es para permitir un nombre de archivo en lugar de una URL. Principalmente para facilitar las pruebas.
    \item -T, --tables; Procesa los elementos \emph{tables} del archivo y genera un archivo con atributos y hechos.
    \item -d0; Las capacidades recursivas no fueron implementadas para el proceso de procesar tablas. Con esto nos aseguramos no tener errores de compatibilidad con el codigo original.    
\end{itemize}

Y se han agregado los siguientes metodos para encapsular las operaciones necesarias para implementar los argumentos agregados.
\begin{itemize}
    \item html2Hechos: que procesa la fuente de datos actual, construyendo un listado con sus tablas.
    \item getHechos: utiliza html2Hechos, y procesa su resultado generando atributos y hechos para cada tabla.
\end{itemize}

Para procesar un archivo utilizaremos una de las siguientes combinaciones de argumentos:
\begin{itemize}
    \item Si se desea procesar una URL: 
        \begin{center}
        \begin{verbatim}
            $ python crawler.py url -T -d0 >fecha.hora.hechos.txt
        \end{verbatim}
        \end{center}

    \item Si se desea procesar un archivo local indicado con un path relativo.
        \begin{center}
        \begin{verbatim}
            $ python crawler.py -F archivo -T -d0 >fecha.hora.hechos.txt
        \end{verbatim}
        \end{center}
\end{itemize}

La salida puede ser guardada en un archivo intermedio, o concatenada con otro archivo mediante el comando \emph{cat} o similar.

\subsection{ecuacion}
Este modulo provee las facilidades de un interprete de ecuaciones en notacion infija (ejemplo: A+B) y la construcción de una pila de argumentos y operadores en notacion polaca inversa o postfija (ejemplo: A B +). Su utilidad radica en que la notacion polaca inversa no requiere de parentesis para separar sus operaciones, y simplifica la construcción de la red de inferencia al momento de definir una regla.

Permite además representar la ecuacion en notacion infija.

Al momento de procesar una expresion, reconoce los parentesis, llaves y corchetes, pero no hace distinción entre ellos.

El modulo puede ser usado para operadores de cualquier aridad, pero nosotros solo hemos utilizado operadores binarios.

\subsection{evaluador}
Este modulo agrupa objetos encargados de comparar valores, su unica utilidad es la de aplicar el patrón \emph{factory method} a la construcción de operadores y simplificar la clase \emph{motor.OperadorBinario} (aplicando el patron \emph{template method}).

El modulo define un punto de acceso a la construcción de los evaluadores definidos en ella \emph{evaluador.factory}, que gracias a su metodo \emph{create} se puede construir un operador a partir de su simbolo. Como los evaluadores son simples y solo proveen un nombre y una llamada, se ha optado por devolver directamente siempre la misma instancia (en lugar de crear un objeto nuevo en cada llamada al metodo).

Es importante notar que si se vuelve necesario extender las operaciones (solo binarias) que se pueden utilizar para difinir reglas; solo es necesario modificar este modulo.

Solo se han definido los operadores necesarios:
\begin{itemize}
    \item \emph{Conjuncion}, \emph{Disjuncion}; operadores logicos AND y OR respectivamente.
    \item \emph{MenorFloat}, \emph{MayorFloat}, \emph{IgualFloat}, \emph{DistintoFloat}, \emph{SumaFloat}, \emph{RestaFloat}, \emph{MultiplicacionFloat}, \emph{DivisionFloat}; operadores sobre valores númericos, todos devuelven un numero de punto flotante. Y lanzaran una excepción si se trata de comparar dos valores no numericos.
    \item EvaluadorGenerico; Este comparador agrega más opciones pero agrega la logica necesaria en cada operación, se utiliza para las comparaciones por igual o distinto.
\end{itemize}

\subsection{mixins}
Contiene tres clases de utilidad para la utilizar una gramatica común en todas las clases:
\begin{itemize}
    \item \emph{Nombre}: atributo cadena de caracteres.
    \item \emph{Entrenamiento}: atributo logico.
    \item \emph{Outputs}: conjunto de enlaces de salida, y provee el metodo \emph{foward\_cast}, que implementa el algoritmo \emph{flooding} para recorrer los enlaces.
\end{itemize}

\subsection{motor}
Este modulo define un motor de inferencia con un grafo dirigido (\emph{RedDeInferencia}) que propaga hechos desde los nodos que represetan los atributos hasta llegar a las nodos que representan reglas, todos los nodos intermedios son operadores binarios.

A tal fin las clases definidas son:
\begin{itemize}
    \item \emph{Hecho}: representa una situación que puede o no disparar alguna regla, esta constituida por un conjunto de pares \emph{atributo = valor}. Además de contener los atributos, permite comprobar si dos instancias son equivalentes, lo cual solo es cierto si tienen los mismos atributos y estos tienen los mismos valores (este método es utilizado para no almacenar dos veces hechos equivalentes).
    \item \emph{HechoAglomerado}: Es un conjunto de uno o mas hechos, y agrega el atributo resultado que representa el estado de aplicar al conjunto de hechos todos los operadores anteriores en la red. Tambien se utiliza para combinar hechos cuando la red esta en modo de entrenamiento.

    \item \emph{Atributo}; Un atributo es un nodo de entrada a la red de inferencia, identificado con su nombre. Su unica función es la de solo difundir a la red hechos que lo contienen como atributo.

    En modo entrenamiento un atributo almacena todos los hechos relevantes que han sido propagados.

    \item \emph{Constante}; Una constante define un nombre y un valor para ella. Se usa en la red para configurar los operadores binarios que solo comparan el valor de un atributo contra una constante.

    \item \emph{OperadorBinario}; Son nodos intermedios de la red que se encargan de realizar una operacion entre dos entradas. Solo propaga los hechos que cumplen con la operacion indicada. Si es una operacion aritmetica simplemente debe tener el los atributos necesarios para evaluarla, si es una condición logica además debe comprovarse verdadera.

    El operador binario se compone de una instancia de \emph{evaluador.Evaluador} que le permite abstrarse de la operación que realiza.

    En modo entrenamiento un operador binario debe registrar los hechos que le arriban y saber de cual de sus enlaces le ha llegado, luego además de intentar propagar ese hecho, debe intentar combinarlo con los que aporto el otro enlace de entrada a la busqueda de nuevos hechos que puedan llegar a alguna regla.

    \item \emph{Regla}; Son nodos terminales (no siguen propagando hechos), al arribar a ellos un hecho ya se sabe que este hecho la dispara por lo que se dispara el metodo \emph{consecuencia}; el prototipo solamente la almacena en el conjunto de hechos, pero el tratamiento de los hechos podria directamente la finalización del programa ante la primer regla disparada.

    \item \emph{RedDeInferencia}; La red de inferencia almacena en diccionarios la base de datos de atributos, constantes, reglas y operadores binarios, provee metodos para agregar elementos a partir de cadenas de caracteres.

    En escencia la red de inferencia es un grafo dirigido aciclico, donde pueden identificarse facilmente tres grupos de nodos, un conjunto de nodos de entrada (atributos), un conjunto de nodos de salida (reglas), y una nube de nodos intermedios (operadores binarios).

    Su unica función es la de construir nodos y sus conexiones; y permitir el ingreso correcto de hechos a travez de los atributos para propagarlos por la red para lograr disparar alguna regla, así como proveer una manera de consultar el estado de la red.

    \item \emph{\_LinkHandler}: Es una clase de utilidad que encapusla la definicion de los enlaces entrantes.

\end{itemize}

\subsection{motor.main}
El ejecutable principal del motor de inferencia.

Además de ser un cascaron para acceder a las capacidades del modulo \emph{motor}, genera los informes por pantalla y en formato HTML de los resultados de ejecutar un modelo (atributos, reglas y hechos).

Funciona como un interprete de comandos\footnote{extiende \emph{cmd.Cmd}}, leyendolos de entrada estandard y emitiendo sus resultados en la salida estandard, los errores o mensajes de información se presentan en la salida de error.

\subsubsection{Gramatica}
Los comandos que definen atributos, constantes, reglas y hechos aceptan como argumento la representación en cadena de caracteres de los mismos.
Si el primer caracter no blanco de una linea es `\#' la linea es conciderada un comentario e ignorada.

Los comandos validos son:
\begin{itemize}
    \item \texttt{ENTRENAR}; Configura el motor en modo de entrenamiento (los hechos son almacenados en los operadores y los atributos).
    \item \texttt{PRODUCIR}; Configura el motor en modo de producción (no entrenamiento).
    \item \texttt{ATRIBUTO nombre}; Agrega al motor la definición de un atributo.
    \item \texttt{CONSTANTE nombre=valor}; Define una constante
    \item \texttt{REGLA nombre: ecuacion}; Define una regla a partir de una cadena de caracteres y la agrega al motor.
    \item \texttt{HECHO nombre atributo1=valor1, atributo2=valor2, ...}; Construye un hecho y lo difunde por la red del motor de inferencia. 
    \item \texttt{ESTADO}; Presenta por pantalla un informe del estado del motor.
    \item \texttt{INFORME\_HTML archivo}; Imprime un informe del estado del motor en formato HTML. El argumento \emph{archivo} es opcional y permite guardar el informe en el archivo indicado, si no se provee se imprime por salida estandard.

    El informe sigue algunos lineamentos basicos:
    \begin{itemize}
        \item Se utiliza \emph{HTML5}.
        \item El informe no utiliza \emph{CSS}, para permitir su adecuacion cualquier pagina que desee usarlo.
        \item En cada regla activada se resaltan los valores de los atributos involucrados en ella en cada hecho disparador.
        
    \end{itemize}        

    \item \texttt{ECO True/False}; Configura la bandera \emph{eco}, si es verdadera imprimira antes de procesar una linea su contenido, en caso contrario no tiene efecto. Si solo se utiliza \texttt{ECO} el resultado es simplemente cambiar al valor opuesto al actual.
    \item \texttt{AYUDA} (alias de \texttt{HELP}); Si se utiliza el motor en forma interactiva, estos comandos son capaces de dar una pequeña ayuda de los comandos reconocidos.
    \item \texttt{SALIR} (alias de \emph{EOF}); Tanto el comando \emph{salir}, como el caracter de fin de archivo son validos para terminar la ejecución del interprete.
\end{itemize}

\subsubsection{Ejemplo de red de inferencia}
En la figura \ref{fig:ej1} se presenta la estructura del grafo dirigido construido luego ejecutar los comandos siguientes:

\begin{lstlisting}
ATRIBUTO A
ATRIBUTO B
ATRIBUTO C
REGLA A&B
REGLA A&B&C
REGLA C=True
\end{lstlisting}

Las primeras tres lineas, crearan las instancias de \emph{Atributo} correspondientes.

La cuarta linea, creara un nodo \emph{OperadorBinario} para realizar la operacion \emph{A\&B} y lo agregara a los vecinos salientes de los atributos \emph{A} y \emph{B}. Luego se creara una instancia de \emph{Regla} y se agrega la misma a los vecinos salientes del nodo.

La quinta linea, tratara de construir los nodos, descubrira que ya existe \emph{A\&B} y solo creara los nodos necesarios.

La sexta linea, es similar a la cuarta, pero al procesar \emph{True} no lo encontrara entre los atributos conocidos y asumira que es una constante.

Hay que notar que para llevar a cabo sus tareas, los nodos \emph{OperadorBinario} deben conocer a sus dos fuentes de hechos, por lo que se podria decir que las aristas que arriban a los nodos intermedios son bidireccionales.

\begin{figure}[ht!]
\centering
\label{fig:ej1}
\begin{tikzpicture}[scale=.75, auto=left,
    atributo/.style = {circle, line width=1pt, draw=black, fill=blue!50},
    constante/.style = {circle, line width=1pt, draw=black, fill=red!50},
    operador/.style = {circle, line width=1pt, draw=black, fill=orange!50},
    regla/.style = {circle, line width=1pt, draw=black, fill=green!50}]

    \node[atributo] (A) at (1,7) {A};
    \node[atributo] (B) at (1,5) {B};
    \node[atributo] (C) at (1,3) {C};
    \node[constante] (True) at (3,1) {True};
    \node[operador] (AandB) at (3,6) {A\&B};
    \node[operador] (AandBandC) at (5,4) {A\&B\&C};
    \node[operador] (CeqTrue) at (5,1.5) {C=True};c
    \node[regla] (rAandB) at (8,6) {A\&B};
    \node[regla] (rAandBandC) at (8,4) {A\&B\&C};
    \node[regla] (rCeqTrue) at (8,1.5) {C=True};

    \foreach \from/\to in {AandB/A, AandB/B, rAandB/AandB,
                           AandBandC/C, AandBandC/AandB, rAandBandC/AandBandC,
                           CeqTrue/C, CeqTrue/True, rCeqTrue/CeqTrue}
        \draw[<-, thick, draw=black] (\from) -- (\to);

\end{tikzpicture}
\caption{Ejemplo de estado de una red de inferencia}
\end{figure}

\subsection{Reglas}
La manera de definir reglas requiere que se definan con anterioridad los atributos, y las constantes de la forma \emph{constante=valor}, cualquier otro elemento de una regla que no este definido con anterioridad sera definido como una constante de la forma \emph{valor=valor}.

Las reglas se definen en notación infija, pero como el modulo \emph{ecuacion} no reconoce prioridad de operadores, se vuelve necesario especificar el orden de operación con parentesis (en su escritura infija).

Una regla deberia terminar en un valor verdadero o falso. Cualquier valor que se considere verdadero en \emph{python} disparara la regla.

\newpage
\section{Diagramas de clases}
Se han seguido los siguientes lineamientos para construir los diagramas de clases:
\begin{itemize}
    \item Para indicar que cualquier instancia puede ser utilizada como parametro se utiliza el tipo \emph{object}
    \item Para indicar una metodo de clase, se utiliza \copyright.
    \item Se utilizan los nombres completos de los metodos sin \emph{self}.
    \item Todos los atributos y metodos son publicos en \emph{python}, por lo que no se muestra indicadores de visibilidad. Igualmente se debe tener en cuenta la convencion; si un metodo comienza con un caracter \_ quiere decir que es privado.
    \item Si el constructor posee un nombre de atributo en lugar de un tipo, esto indica que el parametro es asignado a la variable privada correspondiente.
    \item \emph{\_Factory.create} devuelve instancias que implementan \emph{EvaluadorAbstracto}
\end{itemize}

\begin{figure}[!ht]
\centering \includegraphics[scale=0.6]{atr_const_hecho_clases.png}
\caption{Clases definidias en el modulo \emph{mixins}, y las clases basicas del modulo \emph{motor}}
\end{figure}

\begin{figure}[!ht]
\centering \includegraphics[scale=0.6]{evaluador_clases.png}
\caption{Clases definidas en el modulo \emph{evaluador}}
\end{figure}

\begin{figure}[!ht]
\centering \includegraphics[scale=0.6]{opbin_clase.png}
\caption{Clase \emph{OperadorBinario} dentro del modulo \emph{motor}}
\end{figure}

\begin{figure}[!ht]
\centering \includegraphics[scale=0.6]{red_clase.png}
\caption{Clase \emph{RedDeInferencia} y sus relaciones}
\end{figure}

\begin{figure}[!ht]
\centering \includegraphics[scale=0.6]{regla_clase.png}
\caption{Clase \emph{Regla} y sus relaciones con las demas}
\end{figure}

\newpage
\section{Escenario: recomendaciónes bursatiles}
El escenario del trabajo práctico es la construcción de un proceso que sea capaz de captar información de una pagina web, y que a partir de la misma y un conjunto de reglas, logre detectar cuales se han cumplido.

Nuestra solución obtiene el objetivo de la siguiente manera:
\begin{itemize}
    \item Definimos un archivo de texto de reglas (\emph{reglas.txt}). Solo es necesario modificar este archivo para utilizar un conjunto de reglas distinto. Es conveniente que este archivo contenga las definiciones de atributos y constantes.
    \item Definimos dos archivos de texto: \emph{informe\_html.txt} y \emph{estado.txt}. Cada uno solo contiene una linea, el primero con \emph{INFORME\_HTML} y el segundo solo \emph{ESTADO} 
    \item Procesamos la dirección URL, y generamos los hechos a partir de la misma.
    \item Juntamos los archivos anteriores y alimentamos el motor con el resultado.
\end{itemize}

\subsection{Ejemplo:}
El siguiente ejemplo de invociación construye un archivo de hechos a partir de una URL, luego une su contenido con las reglas definidas para completar el modelo, finalmente utiliza el motor para interpretar el contenido y presentar un informe en formato HTML. El ejemplo utiliza archivos intermedios por legibilidad pero podria ser reescrito en una sola tuberia.

\begin{lstlisting}
$ python crawler.py url -T -d0 >fecha.hora.hechos.txt
$ cat reglas.txt fecha.hora.hechos.txt informe_html.txt > modelo.txt
$ python motor.main.py <modelo.txt >fecha.hora.reporte.html
\end{lstlisting}

Hemos utilizado la siguiente pagina: \emph{http://www.merval.sba.com.ar/Vistas/Cotizaciones/Acciones.aspx} como fuente para recolectar informacion.

\newpage
\subsubsection{Reglas definidas en MervalAcciones.reglas.txt}
Las reglas son muy simples y son solo ejemplos de recomendaciones.
\lstinputlisting{../python/MervalAcciones.reglas.txt}

\section{Conclusiones}

\subsection{Mejoras}

\end{document}



